package com.cn.map;

import java.util.*;

/**
 * Map常用方法
 * 1. V put(K key,V   value)
 *    作用：向Map中添加一个键值对。如果键已经存在，则更新其对应的值，并返回旧值；如果键不存在，则返回 null。
 *
 * 2. V remove(Object key)
 *    作用：根据键删除键值对，返回被删除键所对应的值。如果键不存在，返回 null。
 *
 * 3. void clear()
 *    作用：清空 Map 中的所有键值对，Map 变为空。
 *
 * 4. boolean containsKey(Object key)
 *    作用：判断 Map 中是否包含指定的键。
 *
 * 5. boolean containsValue(Object value) 判断集合是否包含指定的值
 *    作用：判断 Map 中是否包含指定的值。
 *
 * 6. boolean isEmpty()
 *    作用：判断 Map 是否为空。如果没有键值对，返回 true。
 *
 * 7. int size() 返回 Map 中键值对的个数。
 *    作用：返回 Map 中键值对的个数。
 *
 * 8. V get(Object key)
 *    作用：根据键获取对应的值。如果键不存在，返回 null。
 *
 * 9. Set keySet()
 *    作用：返回 Map 中所有键的集合（Set）。
 * 10. Collection values()
 *    作用：返回 Map 中所有值的集合（Collection）。
 *
 * 11. Set<Map.Entry<K,V>> entrySet()
 *    作用：返回 Map 中所有键值对的集合（Set<Map.Entry<K, V>>）。
 * 	  用途：可以用来遍历 Map 的键值对。
 */
public class Map_02_Methods {
    public static void main(String[] args) {
        //1. V put(K key,V value)：添加元素
        //向 Map 中添加一个键值对。如果键已经存在，则更新其对应的值，并返回旧值；如果键不存在，则返回 null。
        Map<String, Integer> map1 = new HashMap<>();
        map1.put("A", 1); // 添加键值对 A=1
        map1.put("B", 2); // 添加键值对 B=2
        Integer oldValue = map1.put("A", 10); // 更新 A 的值为 10，返回旧值 1
        System.out.println(oldValue); // 输出 1

        //2. V remove(Object key)：根据键删除键值对元素
        //根据键删除键值对，返回被删除键所对应的值。如果键不存在，返回 null。
        Map<String, Integer> map2 = new HashMap<>();
        map2.put("A", 1);
        map2.put("B", 2);
        Integer removedValue = map2.remove("A"); // 删除键 A，返回值 1
        System.out.println(removedValue); // 输出 1
        System.out.println(map2); // 输出 {B=2}

        //3. void clear() 移除所有的键值对元素
        Map<String, Integer> map3 = new HashMap<>();
        map3.put("A", 1);
        map3.put("B", 2);
        map3.clear(); // 清空所有键值对
        System.out.println(map3); // 输出 {}

        //4. boolean containsKey(Object key)：判断集合是否包含指定的键
        Map<String, Integer> map4 = new HashMap<>();
        map4.put("A", 1);
        boolean containsA = map4.containsKey("A"); // 检查是否包含键 A
        System.out.println(containsA); // 输出 true


        //5. boolean containsValue(Object value) 判断 Map 中是否包含指定的值。
        Map<String,Integer> map5 = new HashMap<>();
        map5.put("A",1);
        boolean result1 = map5.containsValue(1);
        System.out.println(result1);

        //6. boolean isEmpty(): 判断 Map 是否为空。如果没有键值对，返回 true。
        Map<String,Integer> map6 = new HashMap<>();
        map6.put("A",1);
        System.out.println(map6.isEmpty());

        //7. int size() 作用：返回 Map 中键值对的个数。
        Map<String, Integer> map7 = new HashMap<>();
        map7.put("A", 1);
        map7.put("B", 2);
        System.out.println(map7.size()); // 输出 2

        // 8. V get(Object key) 作用：根据键获取对应的值。如果键不存在，返回 null。
        Map<String, Integer> map8 = new HashMap<>();
        map8.put("A", 1);
        Integer value = map8.get("A"); // 获取键 A 对应的值
        System.out.println(value); // 输出 1

        // 9. Set<K> keySet() 作用：返回 Map 中所有键的集合（Set）。
        Map<String, Integer> map9 = new HashMap<>();
        map9.put("A", 1);
        map9.put("B", 2);
        Set<String> keys = map9.keySet(); // 获取所有键的集合
        System.out.println(keys); // 输出 [A, B]

        //10. Collection<V> values() 作用：返回 Map 中所有值的集合（Collection）。
        Map<String, Integer> map10 = new HashMap<>();
        map10.put("A", 10);
        map10.put("B", 20);
        map10.put("C", 30);

        // 获取值的集合
        // values 是一个 Collection<Integer> 类型的集合，包含了 Map 中所有的值
        // 尽管返回的是 Collection，但本质上它是一个与原始 Map 关联的视图。因此对返回的 Collection 的修改也会影响原 Map。
        Collection<Integer> values = map10.values();
        System.out.println("Collection: " + values);

        // 如果需要将 Collection 转换为其他具体的集合类型（例如 List 或 Set），可以通过构造方法来实现。
        // 转换为 List
        List<Integer> valueList = new ArrayList<>(values);
        System.out.println("List: " + valueList);

        // 转换为 Set
        Set<Integer> valueSet = new HashSet<>(values);
        System.out.println("Set: " + valueSet);


        //11. Set<Map.Entry<K, V>> entrySet()
        //作用：返回 Map 中所有键值对的集合（Set<Map.Entry<K, V>>）。
        Map<String, Integer> map11 = new HashMap<>();
        map11.put("A", 1);
        map11.put("B", 2);
        for (Map.Entry<String, Integer> entry : map11.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }
        // 输出:
        // A -> 1
        // B -> 2


    }
}
